package com.obggtc.picture.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * 视频缓存工具类
 */
@Component
public class VideoCacheUtils {

    @Autowired
    private RedisUtils redisUtils;

    // Redis Key前缀
    private static final String VIDEO_INFO_PREFIX = "video:info:";
    private static final String VIDEO_VIEW_COUNT_PREFIX = "video:view:";
    private static final String HOT_VIDEOS_KEY = "video:hot:list";
    private static final String USER_VIDEOS_PREFIX = "user:videos:";
    private static final String VIDEO_TAGS_PREFIX = "video:tags:";
    private static final String TAG_VIDEOS_PREFIX = "tag:videos:";
    private static final String RECENT_VIDEO_UPLOADS_KEY = "video:recent:uploads";
    private static final String VIDEO_PROCESSING_PREFIX = "video:processing:";

    // 默认缓存时间（秒）
    private static final long DEFAULT_CACHE_TIME = 7200; // 2小时（视频缓存时间较长）
    private static final long HOT_VIDEOS_CACHE_TIME = 3600; // 1小时
    private static final long VIEW_COUNT_CACHE_TIME = 86400; // 24小时
    private static final long PROCESSING_CACHE_TIME = 1800; // 30分钟

    /**
     * 缓存视频基本信息
     * @param videoId 视频ID
     * @param videoInfo 视频信息（包含文件名、大小、时长、分辨率等）
     */
    public void cacheVideoInfo(String videoId, Map<String, Object> videoInfo) {
        String key = VIDEO_INFO_PREFIX + videoId;
        redisUtils.hmset(key, videoInfo, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取视频基本信息
     * @param videoId 视频ID
     * @return 视频信息
     */
    public Map<Object, Object> getVideoInfo(String videoId) {
        String key = VIDEO_INFO_PREFIX + videoId;
        return redisUtils.hmget(key);
    }

    /**
     * 删除视频缓存信息
     * @param videoId 视频ID
     */
    public void removeVideoInfo(String videoId) {
        String key = VIDEO_INFO_PREFIX + videoId;
        redisUtils.del(key);
    }

    /**
     * 增加视频观看次数
     * @param videoId 视频ID
     * @return 当前观看次数
     */
    public long incrementViewCount(String videoId) {
        String key = VIDEO_VIEW_COUNT_PREFIX + videoId;
        long count = redisUtils.incr(key, 1);
        // 设置过期时间
        if (count == 1) {
            redisUtils.expire(key, VIEW_COUNT_CACHE_TIME);
        }
        return count;
    }

    /**
     * 获取视频观看次数
     * @param videoId 视频ID
     * @return 观看次数
     */
    public long getViewCount(String videoId) {
        String key = VIDEO_VIEW_COUNT_PREFIX + videoId;
        Object count = redisUtils.get(key);
        return count != null ? Long.parseLong(count.toString()) : 0L;
    }

    /**
     * 批量获取视频观看次数
     * @param videoIds 视频ID列表
     * @return 观看次数映射
     */
    public Map<String, Long> batchGetViewCounts(List<String> videoIds) {
        Map<String, Long> result = new java.util.HashMap<>();
        for (String videoId : videoIds) {
            result.put(videoId, getViewCount(videoId));
        }
        return result;
    }

    /**
     * 添加到热门视频列表
     * @param videoId 视频ID
     * @param score 热度分数（可以基于观看量、点赞数、评论数等计算）
     */
    public void addToHotVideos(String videoId, double score) {
        // 使用列表存储
        redisUtils.lSet(HOT_VIDEOS_KEY, videoId);
        // 保持列表大小
        long size = redisUtils.lGetListSize(HOT_VIDEOS_KEY);
        if (size > 50) {
            redisUtils.lRemove(HOT_VIDEOS_KEY, -1, 
                redisUtils.lGetIndex(HOT_VIDEOS_KEY, -1));
        }
        redisUtils.expire(HOT_VIDEOS_KEY, HOT_VIDEOS_CACHE_TIME);
    }

    /**
     * 获取热门视频列表
     * @param count 返回数量
     * @return 热门视频ID列表
     */
    public List<Object> getHotVideos(int count) {
        return redisUtils.lGet(HOT_VIDEOS_KEY, 0, count - 1);
    }

    /**
     * 缓存用户的视频列表
     * @param username 用户名
     * @param videoIds 视频ID列表
     */
    public void cacheUserVideos(String username, List<String> videoIds) {
        String key = USER_VIDEOS_PREFIX + username;
        redisUtils.del(key); // 先清除旧数据
        if (!videoIds.isEmpty()) {
            redisUtils.lSet(key, videoIds, DEFAULT_CACHE_TIME);
        }
    }

    /**
     * 添加用户上传的视频
     * @param username 用户名
     * @param videoId 视频ID
     */
    public void addUserVideo(String username, String videoId) {
        String key = USER_VIDEOS_PREFIX + username;
        redisUtils.lSet(key, videoId);
        redisUtils.expire(key, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取用户的视频列表
     * @param username 用户名
     * @return 视频ID列表
     */
    public List<Object> getUserVideos(String username) {
        String key = USER_VIDEOS_PREFIX + username;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 从用户视频列表中移除视频
     * @param username 用户名
     * @param videoId 视频ID
     */
    public void removeUserVideo(String username, String videoId) {
        String key = USER_VIDEOS_PREFIX + username;
        redisUtils.lRemove(key, 1, videoId);
    }

    /**
     * 缓存视频标签
     * @param videoId 视频ID
     * @param tags 标签列表
     */
    public void cacheVideoTags(String videoId, List<String> tags) {
        String key = VIDEO_TAGS_PREFIX + videoId;
        redisUtils.del(key);
        if (!tags.isEmpty()) {
            redisUtils.lSet(key, tags, DEFAULT_CACHE_TIME);
        }
    }

    /**
     * 获取视频标签
     * @param videoId 视频ID
     * @return 标签列表
     */
    public List<Object> getVideoTags(String videoId) {
        String key = VIDEO_TAGS_PREFIX + videoId;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 为标签添加视频
     * @param tag 标签
     * @param videoId 视频ID
     */
    public void addVideoToTag(String tag, String videoId) {
        String key = TAG_VIDEOS_PREFIX + tag;
        redisUtils.lSet(key, videoId);
        redisUtils.expire(key, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取标签下的视频列表
     * @param tag 标签
     * @return 视频ID列表
     */
    public List<Object> getVideosByTag(String tag) {
        String key = TAG_VIDEOS_PREFIX + tag;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 添加到最近上传视频列表
     * @param videoId 视频ID
     */
    public void addToRecentUploads(String videoId) {
        // 添加到列表头部
        redisUtils.lSet(RECENT_VIDEO_UPLOADS_KEY, videoId);
        
        // 保持列表大小不超过50（视频数量相对较少）
        long size = redisUtils.lGetListSize(RECENT_VIDEO_UPLOADS_KEY);
        if (size > 50) {
            // 移除最后的元素
            redisUtils.lRemove(RECENT_VIDEO_UPLOADS_KEY, -1, 
                redisUtils.lGetIndex(RECENT_VIDEO_UPLOADS_KEY, -1));
        }
        
        // 设置过期时间
        redisUtils.expire(RECENT_VIDEO_UPLOADS_KEY, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取最近上传的视频列表
     * @param count 返回数量
     * @return 最近上传的视频ID列表
     */
    public List<Object> getRecentUploads(int count) {
        return redisUtils.lGet(RECENT_VIDEO_UPLOADS_KEY, 0, count - 1);
    }

    /**
     * 缓存视频缩略图信息
     * @param videoId 视频ID
     * @param thumbnailPath 缩略图路径
     * @param duration 视频时长（秒）
     */
    public void cacheThumbnailInfo(String videoId, String thumbnailPath, Long duration) {
        String key = VIDEO_INFO_PREFIX + videoId;
        redisUtils.hset(key, "thumbnailPath", thumbnailPath, DEFAULT_CACHE_TIME);
        redisUtils.hset(key, "duration", duration.toString(), DEFAULT_CACHE_TIME);
    }

    /**
     * 获取视频缩略图路径
     * @param videoId 视频ID
     * @return 缩略图路径
     */
    public String getThumbnailPath(String videoId) {
        String key = VIDEO_INFO_PREFIX + videoId;
        Object path = redisUtils.hget(key, "thumbnailPath");
        return path != null ? path.toString() : null;
    }

    /**
     * 获取视频时长
     * @param videoId 视频ID
     * @return 视频时长（秒）
     */
    public Long getVideoDuration(String videoId) {
        String key = VIDEO_INFO_PREFIX + videoId;
        Object duration = redisUtils.hget(key, "duration");
        return duration != null ? Long.parseLong(duration.toString()) : null;
    }

    /**
     * 设置视频处理状态
     * @param videoId 视频ID
     * @param status 处理状态（uploading, processing, completed, failed）
     * @param progress 处理进度（0-100）
     */
    public void setProcessingStatus(String videoId, String status, Integer progress) {
        String key = VIDEO_PROCESSING_PREFIX + videoId;
        Map<String, Object> statusInfo = new java.util.HashMap<>();
        statusInfo.put("status", status);
        statusInfo.put("progress", progress);
        statusInfo.put("updateTime", System.currentTimeMillis());
        redisUtils.hmset(key, statusInfo, PROCESSING_CACHE_TIME);
    }

    /**
     * 获取视频处理状态
     * @param videoId 视频ID
     * @return 处理状态信息
     */
    public Map<Object, Object> getProcessingStatus(String videoId) {
        String key = VIDEO_PROCESSING_PREFIX + videoId;
        return redisUtils.hmget(key);
    }

    /**
     * 清除视频处理状态
     * @param videoId 视频ID
     */
    public void clearProcessingStatus(String videoId) {
        String key = VIDEO_PROCESSING_PREFIX + videoId;
        redisUtils.del(key);
    }

    /**
     * 统计用户上传的视频数量
     * @param username 用户名
     * @return 视频数量
     */
    public long getUserVideoCount(String username) {
        String key = USER_VIDEOS_PREFIX + username;
        return redisUtils.lGetListSize(key);
    }

    /**
     * 清除所有视频相关缓存
     * @param videoId 视频ID
     */
    public void clearAllVideoCache(String videoId) {
        // 清除视频基本信息
        removeVideoInfo(videoId);
        
        // 清除观看次数
        String viewCountKey = VIDEO_VIEW_COUNT_PREFIX + videoId;
        redisUtils.del(viewCountKey);
        
        // 清除标签信息
        String tagsKey = VIDEO_TAGS_PREFIX + videoId;
        redisUtils.del(tagsKey);
        
        // 清除处理状态
        clearProcessingStatus(videoId);
        
        // 从最近上传列表中移除
        redisUtils.lRemove(RECENT_VIDEO_UPLOADS_KEY, 1, videoId);
    }

    /**
     * 刷新热门视频列表（定时任务使用）
     * 根据观看量、点赞数、评论数等重新计算热门视频
     */
    public void refreshHotVideosList() {
        // 这里可以实现根据观看量、点赞数、评论数等重新计算热门视频的逻辑
        // 具体实现取决于业务需求
    }
} 